home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / gdb.new / gdb-3.98 / gdb / value.h < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-01  |  9.7 KB  |  318 lines
  1. /* Definitions for values of C expressions, for GDB.
  2.    Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
  3.  
  4. This file is part of GDB.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #if !defined (VALUE_H)
  21. #define VALUE_H 1
  22. /*
  23.  * The structure which defines the type of a value.  It should never
  24.  * be possible for a program lval value to survive over a call to the inferior
  25.  * (ie to be put into the history list or an internal variable).
  26.  */
  27. enum lval_type {
  28.   /* Not an lval.  */
  29.   not_lval,
  30.   /* In memory.  Could be a saved register.  */
  31.   lval_memory,
  32.   /* In a register.  */
  33.   lval_register,
  34.   /* In a gdb internal variable.  */
  35.   lval_internalvar,
  36.   /* Part of a gdb internal variable (structure field).  */
  37.   lval_internalvar_component,
  38.   /* In a register series in a frame not the current one, which may have been
  39.      partially saved or saved in different places (otherwise would be
  40.      lval_register or lval_memory).  */
  41.   lval_reg_frame_relative,
  42. };
  43.  
  44. struct value
  45.   {
  46.     /* Type of value; either not an lval, or one of the various
  47.        different possible kinds of lval.  */
  48.     enum lval_type lval;
  49.     /* Location of value (if lval).  */
  50.     union
  51.       {
  52.     /* Address in inferior or byte of registers structure.  */
  53.     CORE_ADDR address;
  54.     /* Pointer to interrnal variable.  */
  55.     struct internalvar *internalvar;
  56.     /* Number of register.  Only used with
  57.        lval_reg_frame_relative.  */
  58.     int regnum;
  59.       } location;
  60.     /* Describes offset of a value within lval a structure in bytes.  */
  61.     int offset;    
  62.     /* Only used for bitfields; number of bits contained in them.  */
  63.     int bitsize;
  64.     /* Only used for bitfields; position of start of field.  */
  65.     int bitpos;
  66.     /* Frame value is relative to.  In practice, this address is only
  67.        used if the value is stored in several registers in other than
  68.        the current frame, and these registers have not all been saved
  69.        at the same place in memory.  This will be described in the
  70.        lval enum above as "lval_reg_frame_relative".  */
  71.     CORE_ADDR frame_addr;
  72.     /* Type of the value.  */
  73.     struct type *type;
  74.     /* Values are stored in a chain, so that they can be deleted
  75.        easily over calls to the inferior.  Values assigned to internal
  76.        variables or put into the value history are taken off this
  77.        list.  */
  78.     struct value *next;
  79.     /* If an lval is forced to repeat, a new value is created with
  80.        these fields set.  The new value is not an lval.  */
  81.     short repeated;
  82.     short repetitions;
  83.     /* Register number if the value is from a register.  Is not kept
  84.        if you take a field of a structure that is stored in a
  85.        register.  Shouldn't it be?  */
  86.     short regno;
  87.     /* If zero, contents of this value are in the contents field.
  88.        If nonzero, contents are in inferior memory at address
  89.        in the location.address field plus the offset field
  90.        (and the lval field should be lval_memory).  */
  91.     char lazy;
  92.     /* If nonzero, this is the value of a variable which does not
  93.        actually exist in the program.  */
  94.     char optimized_out;
  95.     /* Actual contents of the value.  For use of this value; setting
  96.        it uses the stuff above.  Not valid if lazy is nonzero.
  97.        Target byte-order.  We force it to be aligned properly for any
  98.        possible value.  */
  99.     union {
  100.       long contents[1];
  101.       double force_double_align;
  102. #ifdef LONG_LONG
  103.       long long force_longlong_align;
  104. #endif
  105.     } aligner;
  106.  
  107.   };
  108.  
  109. typedef struct value *value;
  110.  
  111. #define VALUE_TYPE(val) (val)->type
  112. #define VALUE_LAZY(val) (val)->lazy
  113. /* VALUE_CONTENTS and VALUE_CONTENTS_RAW both return the address of
  114.    the gdb buffer used to hold a copy of the contents of the lval.  
  115.    VALUE_CONTENTS is used when the contents of the buffer are needed --
  116.    it uses value_fetch_lazy() to load the buffer from the process being 
  117.    debugged if it hasn't already been loaded.  VALUE_CONTENTS_RAW is 
  118.    used when data is being stored into the buffer, or when it is 
  119.    certain that the contents of the buffer are valid.  */
  120. #define VALUE_CONTENTS_RAW(val) ((char *) (val)->aligner.contents)
  121. #define VALUE_CONTENTS(val) ((void)(VALUE_LAZY(val) && value_fetch_lazy(val)),\
  122.                  VALUE_CONTENTS_RAW(val))
  123. extern int value_fetch_lazy ();
  124. #define VALUE_LVAL(val) (val)->lval
  125. #define VALUE_ADDRESS(val) (val)->location.address
  126. #define VALUE_INTERNALVAR(val) (val)->location.internalvar
  127. #define VALUE_FRAME_REGNUM(val) ((val)->location.regnum)
  128. #define VALUE_FRAME(val) ((val)->frame_addr)
  129. #define VALUE_OFFSET(val) (val)->offset
  130. #define VALUE_BITSIZE(val) (val)->bitsize
  131. #define VALUE_BITPOS(val) (val)->bitpos
  132. #define VALUE_NEXT(val) (val)->next
  133. #define VALUE_REPEATED(val) (val)->repeated
  134. #define VALUE_REPETITIONS(val) (val)->repetitions
  135. #define VALUE_REGNO(val) (val)->regno
  136. #define VALUE_OPTIMIZED_OUT(val) ((val)->optimized_out)
  137.  
  138. /* Convert a REF to the object referenced. */
  139.  
  140. #define COERCE_REF(arg)    \
  141. { if (TYPE_CODE ( VALUE_TYPE (arg)) == TYPE_CODE_REF)            \
  142.     arg = value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg)),        \
  143.              unpack_long (VALUE_TYPE (arg),            \
  144.                       VALUE_CONTENTS (arg)));}
  145.  
  146. /* If ARG is an array, convert it to a pointer.
  147.    If ARG is an enum, convert it to an integer.
  148.    If ARG is a function, convert it to a function pointer.
  149.  
  150.    References are dereferenced.  */
  151.  
  152. #define COERCE_ARRAY(arg)    \
  153. { COERCE_REF(arg);                            \
  154.   if (VALUE_REPEATED (arg)                        \
  155.       || TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ARRAY)        \
  156.     arg = value_coerce_array (arg);                    \
  157.   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_FUNC)                   \
  158.     arg = value_coerce_function (arg);                                  \
  159.   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ENUM)            \
  160.     arg = value_cast (builtin_type_unsigned_int, arg);            \
  161. }
  162.  
  163. /* If ARG is an enum, convert it to an integer.  */
  164.  
  165. #define COERCE_ENUM(arg)    \
  166. { if (TYPE_CODE ( VALUE_TYPE (arg)) == TYPE_CODE_REF)            \
  167.     arg = value_ind (arg);                        \
  168.   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ENUM)            \
  169.     arg = value_cast (builtin_type_unsigned_int, arg);            \
  170. }
  171.  
  172. /* Internal variables (variables for convenience of use of debugger)
  173.    are recorded as a chain of these structures.  */
  174.  
  175. struct internalvar
  176. {
  177.   struct internalvar *next;
  178.   char *name;
  179.   value value;
  180. };
  181.  
  182. #include "symtab.h"
  183. LONGEST value_as_long (
  184. #ifdef __STDC__
  185.                value
  186. #endif
  187.                );
  188. double value_as_double (
  189. #ifdef __STDC__
  190.             value
  191. #endif
  192.             );
  193. CORE_ADDR value_as_pointer (
  194. #ifdef __STDC__
  195.                 value
  196. #endif
  197.                 );
  198. LONGEST unpack_long (
  199. #ifdef __STDC__
  200.              struct type *, char *
  201. #endif
  202.              );
  203. double unpack_double (
  204. #ifdef __STDC__
  205.               struct type *, char *, int *
  206. #endif
  207.               );
  208. CORE_ADDR unpack_pointer (
  209. #ifdef __STDC__
  210.               struct type *, char *
  211. #endif
  212.               );
  213. long unpack_field_as_long ();
  214. value value_from_long ();
  215. value value_from_double ();
  216. value value_at ();
  217. value value_at_lazy ();
  218. value value_from_register ();
  219. value value_of_variable ();
  220. value value_of_register ();
  221. value read_var_value ();
  222. value locate_var_value ();
  223. value allocate_value ();
  224. value allocate_repeat_value ();
  225. value value_mark ();
  226. void value_free_to_mark ();
  227. value value_string ();
  228.  
  229. value value_binop ();
  230. value value_add ();
  231. value value_sub ();
  232. value value_coerce_array ();
  233. value value_coerce_function ();
  234. value value_ind ();
  235. value value_addr ();
  236. value value_assign ();
  237. value value_neg ();
  238. value value_lognot ();
  239. value value_struct_elt (), value_struct_elt_for_address ();
  240. value value_field (), value_primitive_field ();
  241. value value_cast ();
  242. value value_zero ();
  243. value value_repeat ();
  244. value value_subscript ();
  245. value value_from_vtable_info ();
  246.  
  247. value value_being_returned ();
  248. int using_struct_return ();
  249. void set_return_value ();
  250.  
  251. value evaluate_expression ();
  252. value evaluate_type ();
  253. value parse_and_eval ();
  254. value parse_to_comma_and_eval ();
  255. extern CORE_ADDR parse_and_eval_address ();
  256. extern CORE_ADDR parse_and_eval_address_1 ();
  257.  
  258. value access_value_history ();
  259. value value_of_internalvar ();
  260. void set_internalvar ();
  261. void set_internalvar_component ();
  262. struct internalvar *lookup_internalvar ();
  263.  
  264. int value_equal ();
  265. int value_less ();
  266. int value_zerop ();
  267.  
  268. /* C++ */
  269. value value_of_this ();
  270. value value_static_field ();
  271. value value_x_binop ();
  272. value value_x_unop ();
  273. value value_fn_field ();
  274. value value_virtual_fn_field ();
  275. int binop_user_defined_p ();
  276. int unop_user_defined_p ();
  277. int typecmp ();
  278. void fill_in_vptr_fieldno ();
  279. int destructor_name_p ();
  280.  
  281. #define value_free(val) free (val)
  282. void free_all_values ();
  283. void release_value ();
  284. int record_latest_value ();
  285.  
  286. void registers_changed ();
  287. void read_register_bytes ();
  288. void write_register_bytes ();
  289. void read_register_gen ();
  290. CORE_ADDR read_register ();
  291. void write_register ();
  292. void supply_register ();
  293. void get_saved_register ();
  294.  
  295. void modify_field ();
  296. void type_print ();
  297. void type_print_1 ();
  298.  
  299. /* Possibilities for prettyprint parameters to routines which print
  300.    things.  */
  301. enum val_prettyprint {
  302.   Val_no_prettyprint = 0,
  303.   Val_prettyprint,
  304.   /* Use the default setting which the user has specified.  */
  305.   Val_pretty_default
  306.   };
  307.  
  308. char *baseclass_addr ();
  309. void print_floating ();
  310. int value_print ();
  311. int val_print ();
  312. void print_variable_value ();
  313. char *internalvar_name ();
  314. void clear_value_history ();
  315. void clear_internalvars ();
  316.  
  317. #endif /* value.h not already included.  */
  318.